import { useEffect, useRef, useState, useCallback } from 'react';

/**
 * 性能指标接口
 */
export interface IPerformanceMetrics {
  /** 组件渲染时间（毫秒） */
  renderTime: number;
  /** 内存使用量（MB） */
  memoryUsage: number;
  /** 事件监听器数量 */
  eventListenerCount: number;
  /** 重渲染次数 */
  rerenderCount: number;
  /** 最后更新时间 */
  lastUpdated: number;
}

/**
 * 性能阈值配置
 */
export interface IPerformanceThresholds {
  /** 最大渲染时间（毫秒） */
  maxRenderTime: number;
  /** 最大内存使用量（MB） */
  maxMemoryUsage: number;
  /** 最大事件监听器数量 */
  maxEventListeners: number;
  /** 最大重渲染次数 */
  maxRerenderCount: number;
}

/**
 * 性能警告类型
 */
export type PerformanceWarningType = 
  | 'render_time_exceeded'
  | 'memory_usage_high'
  | 'too_many_listeners'
  | 'excessive_rerenders';

/**
 * 性能警告接口
 */
export interface IPerformanceWarning {
  type: PerformanceWarningType;
  message: string;
  value: number;
  threshold: number;
  timestamp: number;
}

/**
 * 默认性能阈值
 */
const DEFAULT_THRESHOLDS: IPerformanceThresholds = {
  maxRenderTime: 16, // 16ms (60fps)
  maxMemoryUsage: 50, // 50MB
  maxEventListeners: 100,
  maxRerenderCount: 10
};

/**
 * 性能监控Hook
 * @description 监控组件的性能指标并提供警告
 */
export const usePerformanceMonitor = (
  componentName: string,
  thresholds: Partial<IPerformanceThresholds> = {}
) => {
  const finalThresholds = { ...DEFAULT_THRESHOLDS, ...thresholds };
  
  // 性能指标状态
  const [metrics, setMetrics] = useState<IPerformanceMetrics>({
    renderTime: 0,
    memoryUsage: 0,
    eventListenerCount: 0,
    rerenderCount: 0,
    lastUpdated: Date.now()
  });
  
  // 性能警告状态
  const [warnings, setWarnings] = useState<IPerformanceWarning[]>([]);
  
  // 引用
  const renderStartTimeRef = useRef<number>(0);
  const rerenderCountRef = useRef<number>(0);
  const isMonitoringRef = useRef<boolean>(true);

  /**
   * 开始渲染时间测量
   */
  const startRenderMeasurement = useCallback(() => {
    if (!isMonitoringRef.current) return;
    renderStartTimeRef.current = performance.now();
  }, []);

  /**
   * 结束渲染时间测量
   */
  const endRenderMeasurement = useCallback(() => {
    if (!isMonitoringRef.current || renderStartTimeRef.current === 0) return;
    
    const renderTime = performance.now() - renderStartTimeRef.current;
    rerenderCountRef.current += 1;
    
    setMetrics(prev => ({
      ...prev,
      renderTime,
      rerenderCount: rerenderCountRef.current,
      lastUpdated: Date.now()
    }));

    // 检查渲染时间警告
    if (renderTime > finalThresholds.maxRenderTime) {
      addWarning('render_time_exceeded', `组件 ${componentName} 渲染时间过长`, renderTime, finalThresholds.maxRenderTime);
    }

    // 检查重渲染次数警告
    if (rerenderCountRef.current > finalThresholds.maxRerenderCount) {
      addWarning('excessive_rerenders', `组件 ${componentName} 重渲染次数过多`, rerenderCountRef.current, finalThresholds.maxRerenderCount);
    }

    renderStartTimeRef.current = 0;
  }, [componentName, finalThresholds]);

  /**
   * 获取内存使用情况
   */
  const measureMemoryUsage = useCallback(() => {
    if (!isMonitoringRef.current) return;
    
    // 使用performance.memory API（如果可用）
    if ('memory' in performance) {
      const memory = (performance as any).memory;
      const memoryUsage = memory.usedJSHeapSize / (1024 * 1024); // 转换为MB
      
      setMetrics(prev => ({
        ...prev,
        memoryUsage,
        lastUpdated: Date.now()
      }));

      // 检查内存使用警告
      if (memoryUsage > finalThresholds.maxMemoryUsage) {
        addWarning('memory_usage_high', `组件 ${componentName} 内存使用过高`, memoryUsage, finalThresholds.maxMemoryUsage);
      }
    }
  }, [componentName, finalThresholds]);

  /**
   * 估算事件监听器数量
   */
  const estimateEventListeners = useCallback(() => {
    if (!isMonitoringRef.current) return;
    
    // 这是一个简化的估算方法
    // 在实际应用中，可能需要更复杂的监控机制
    const eventListenerCount = document.querySelectorAll('*').length * 0.1; // 估算值
    
    setMetrics(prev => ({
      ...prev,
      eventListenerCount,
      lastUpdated: Date.now()
    }));

    // 检查事件监听器数量警告
    if (eventListenerCount > finalThresholds.maxEventListeners) {
      addWarning('too_many_listeners', `组件 ${componentName} 事件监听器过多`, eventListenerCount, finalThresholds.maxEventListeners);
    }
  }, [componentName, finalThresholds]);

  /**
   * 添加性能警告
   */
  const addWarning = useCallback((
    type: PerformanceWarningType,
    message: string,
    value: number,
    threshold: number
  ) => {
    const warning: IPerformanceWarning = {
      type,
      message,
      value,
      threshold,
      timestamp: Date.now()
    };

    setWarnings(prev => {
      // 限制警告数量，只保留最近的10个
      const newWarnings = [warning, ...prev].slice(0, 10);
      return newWarnings;
    });

    // 在开发环境中输出警告
    if (process.env.NODE_ENV === 'development') {
      console.warn(`[性能警告] ${message}`, {
        component: componentName,
        value,
        threshold,
        type
      });
    }
  }, [componentName]);

  /**
   * 清除警告
   */
  const clearWarnings = useCallback(() => {
    setWarnings([]);
  }, []);

  /**
   * 重置指标
   */
  const resetMetrics = useCallback(() => {
    rerenderCountRef.current = 0;
    setMetrics({
      renderTime: 0,
      memoryUsage: 0,
      eventListenerCount: 0,
      rerenderCount: 0,
      lastUpdated: Date.now()
    });
    setWarnings([]);
  }, []);

  /**
   * 启用/禁用监控
   */
  const setMonitoringEnabled = useCallback((enabled: boolean) => {
    isMonitoringRef.current = enabled;
  }, []);

  // 定期测量内存和事件监听器
  useEffect(() => {
    if (!isMonitoringRef.current) return;

    const interval = setInterval(() => {
      measureMemoryUsage();
      estimateEventListeners();
    }, 5000); // 每5秒测量一次

    return () => clearInterval(interval);
  }, []); // 移除函数依赖，避免无限循环

  // 组件卸载时清理
  useEffect(() => {
    return () => {
      isMonitoringRef.current = false;
    };
  }, []);

  return {
    // 性能指标
    metrics,
    warnings,
    
    // 控制方法
    startRenderMeasurement,
    endRenderMeasurement,
    clearWarnings,
    resetMetrics,
    setMonitoringEnabled,
    
    // 状态
    isMonitoring: isMonitoringRef.current,
    hasWarnings: warnings.length > 0,
    
    // 工具方法
    getWarningsByType: (type: PerformanceWarningType) => 
      warnings.filter(w => w.type === type),
    getLatestWarning: () => warnings[0] || null,
    
    // 性能评分（0-100）
    performanceScore: Math.max(0, 100 - (
      (metrics.renderTime > finalThresholds.maxRenderTime ? 20 : 0) +
      (metrics.memoryUsage > finalThresholds.maxMemoryUsage ? 30 : 0) +
      (metrics.eventListenerCount > finalThresholds.maxEventListeners ? 25 : 0) +
      (metrics.rerenderCount > finalThresholds.maxRerenderCount ? 25 : 0)
    ))
  };
};